//@charset "utf-8";
(function() {

    var thsQuote, thsUtil, thsPassport, thsFileReader, thsExternal, thsFileWriter;
    var cefQuote, cefPassport, cefUtil, cefFileReader, cefExternal, cefFileWriter;

    if (!isIE()) {

        thsQuote = new ThsQuote();
        thsUtil = new ThsUtil();
        thsPassport = new ThsPassport();
        thsFileReader = new ThsFileReader();
        thsFileWriter = new ThsFileWriter();
        thsExternal = new ThsExternal();

        //客户端ThsQuote对象，及相应方法
        cefQuote = {
            /**
             * 获得服务器时间
             * @param  {Function} callback 回调函数，必须带一个参数，表示获得的服务器时间
             * @return {int}               返回一个int类型的10位时间
             */
            getServerTime: function(callback) {
                thsQuote.getServerTime().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 从页面切换到客户端页面，同时同步代码表
             * @param  {obj} param 传一个对象{id:379,code:603538,stocklist:arr.join('|')}
             *                               stocklist:数组字符串，arr是一个股票数组，可以是join('|'),也可以是join(',')
             * @return {null}      null
             */
            syncStockList: function(param) {
                //温馨小提示：chorm版本下这个id是int类型，如果传一个字符串的379，会报错，这里做容错处理
                param.id = parseInt(param.id);
                thsQuote.syncStockList(param);
            },
            /**
             * 是否是交易时间
             * @param  {String}   code     字符串股票代码，例如：'300033,600000'
             * @param  {Function} callback 回调函数，回调函数里面必须传一个值表示返回值，
             * @return {int}               返回0：非交易日，1：交易日
             */
            isTradeTime: function(code, callback) {
                thsQuote.isTradeTime(code).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获得最近一个交易日
             * @param  {int}   lDate       int类型的时间戳，10位数字 通过getServerTime获取
             * @param  {Function} callback 回调函数
             * @return {int}               返回当前最近一天交易日，例如：20170411
             */
            getSHTradeDate: function(lDate, callback) {
                thsQuote.getSHTradeDate(lDate).then(function(data) {
                    callback(data);
                });
            },
            getPreSHTradeDate: function(lDate, callback) {
                thsQuote.getPreSHTradeDate(lDate).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取当前页面的页面号
             * @param  {Function} callback 回调函数
             * @return {Number}            返回当前页面的页面号，如：5716
             */
            getHxCurPageID: function(callback) {
                thsQuote.getHxCurPageID().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取当前页面的名称
             * @param  {Function} callback 回调函数
             * @return {String}            返回当前页面的名称，如：首页
             */
            getHxCurPageName: function(callback) {
                thsQuote.getHxCurPageName().then(function(data) {
                    callback(data);
                });
            },

            //接口文档上考虑干掉
            AreaStatConRequest: function(param, callback) {
                thsQuote.AreaStatConRequest(param).then(function(data) {
                    callback(data);
                });
            },
            //区间统计，历史遗留问题，只能在k线或者分时图调用,否则会循环卡死
            SetAreaStatTime: function(param, callback) {
                thsQuote.SetAreaStatTime(param).then(function(data) {
                    callback(data);
                });
            },
            //这个方法原来有参数，现在没有，待确定
            StartGetAreaStatData: function(code, callback) {
                thsQuote.StartGetAreaStatData(code).then(function(data) {
                    callback(data);
                });
            },
            getStatData: function(params, callback) {
                thsQuote.getStatData(params).then(function(data) {
                    callback(data);
                });
            },
            AreaStatRequest: function(params, callback) {
							thsQuote.AreaStatRequest(params).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获得当前客户端版本号
             * @param  {Function} callback 回调函数
             * @return {String}            当前客户端的版本号
             */
            getVersion: function(callback) {
                thsUtil.getHxVer().then(function(data) {
                    callback(data);
                });
            },

            request: function(params) {
                // var thsQuote = new ThsQuote();
                thsQuote.request(params);
            },
            getData: function(params, callback) {
                // var thsQuote = new ThsQuote();
                thsQuote.getData(params).then(function(data) {
                    callback(data);
                });
            },
            getData2: function(params, callback) {
                // var thsQuote = new ThsQuote();
                thsQuote.getData2(params).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 推送服务
             * @param  {Object} params
             * @return {Object}        返回当前的thsQuote对象，用户取消推送
             */
            registerPush: function(params) {
                //console.log(codes);codes,onPushDataReady
                var self = this;
                var thsQuote = new ThsQuote();
                thsQuote.registerPush(params);
                return thsQuote;
            },
            /*unregisterPush:function(){
                var self = this;
                var length = self.thsQuote.length;
                self.thsQuote[length-1].unregisterPush();
            },*/

            getStockCode: function(code, callback) {
                thsQuote.getStockCode(code).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 根据代码获取其分类
             * @param  {String}   code     股票代码，不带市场
             * @param  {Function} callback 回调函数
             * @return {int}               返回int类型数字，例如：3,各种判断不明所以
             */
            getStockType: function(code, callback) {
                thsQuote.getStockType(code).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取两个时间的周期数
             * @param  {Object}   params   {begintime:20170101,endtime:20170202}
             * @param  {Function} callback 回调函数
             * @return {int}               返回当前周期数，目前都是1
             */
            getPeriodNum: function(params, callback) {
                thsQuote.getPeriodNum(params).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取股票代码和行情代码
             * @param  {String}   code     股票代码例如：'300033'
             * @param  {Function} callback 回调函数
             * @return {String}            股票代码|行情代码
             */
            getIndexAndIndustry: function(code, callback) {
                thsQuote.getIndexAndIndustry(code).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 根据URL创建内切页面
             * @param {Object} params    例如：{id:111,url:''}
             */
            switchPageByURL: function(params) {
                thsQuote.switchPageByURL(params);
            },
            /**
             * 切换页面
             * @param  {Object || Number} params
             *         如果参数是Object
             *             id [Integer]: 页面id
             *             code [String]: 目标股票代码，不带市场
             *             period [Interger]: 周期
             *         如果参数是Number，直接传入页面ID
             *
             * @return {null}        null
             */
            switchPage: function(params) {
                thsQuote.switchPage(params);
            },
            /**
             * 切换页面代码
             * @param  {String} code 股票代码,例如'300033'
             * @return {null}      null
             */
            switchCode: function(code) {
                thsQuote.switchCode(code);
            }
        };

        //Passport对象
        cefPassport = {
            /**
             * 获得当前用户的自选股
             * @param  {Function} callback 回调函数
             * @return {String}            返回一个带花括号的数组(['300033','600000'])
             */
            selfStocks: function(callback) {
                thsPassport.selfStocks().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取指定字段的通行证内容
             * @param  {String}   key      通行证字段，例如：'userid,account'
             * @param  {Function} callback 回调函数
             * @return {String}            返回一个指定字段的value值
             */
            get: function(key, callback) {
                thsPassport.get(key).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获得当前账号名称
             * @param  {Function} callback 回调函数
             * @return {String}            目前都返回([{}])这个字符串，未取到任何数据
             */
            getAccountInfo: function(callback) {
                thsPassport.getAccountInfo().then(function(data) {
                    callback(data);
                });
            },
            getAccountAllInfo: function(account, callback) {
                thsPassport.getAccountAllInfo(account).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取所有自选股的所属行业代码
             * @param  {Function} callback 回调函数
             * @return {String}            以','隔开的所属行业代码，例如881148,881153,881118
             */
            selfIndustries: function(callback) {
                thsPassport.selfIndustries().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获得当前用户的密码
             * @param  {Function} callback 回调函数
             * @return {String}            返回加密后的字符串
             */
            getPassword: function(callback) {
                thsPassport.getPassword().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 判断当前账号是否具有level2权限
             * @param  {Function} callback 回调函数
             * @return {Boolean}           返回true或者false
             */
            IsLevel2User: function(callback) {
                thsPassport.IsLevel2User().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获得当前用户的自选股
             * @param  {Function} callback 回调函数
             * @return {String}            返回一个JSON字符串，不过带了括号，需要用eval解析,
             *                             例如返回的是：(['300033','600000'])
             *                             解析可以用eval(data)
             */
            selfStocks: function(callback) {
                thsPassport.selfStocks().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获得下单的持仓代码表
             * @param  {Function} callback 回调函数
             * @return {String}            JSON字符串类型，不过带了括号，需要用eval解析
             *                             例如返回的是：(['300033','600000'])
             *                             解析可以用eval(data)
             */
            holdStocks: function(callback) {
                thsPassport.holdStocks().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获得当前行情页面的代码表
             * @param  {Function} callback 回调函数
             * @return {String}            返回当前行情页面代码表,例如:300033
             */
            curStock: function(callback) {
                thsPassport.curStock().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取指定类型（行情、资讯）主站列表？不确定
             * @param  {[type]}   type     单字符，指定类型？目前未知传什么
             * @param  {Function} callback 回调函数
             * @return {String}            字符串主站列表
             */
            getPassport: function(type, callback) {
                thsPassport.getPassport(type).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取指定类型（行情、资讯）数字签名
             * @param  {[type]}   type     单字符，指定类型？目前未知传什么
             * @param  {Function} callback 回调函数
             * @return {String}            字符串数字签名
             */
            getSignature: function(type, callback) {
                thsPassport.getSignature(type).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取指定代码的市场，即把不可见的字符串转成可见字符串
             * @param  {String}   code     带市场的代码
             * @param  {Function} callback 回调函数
             * @return {String}            代码市场的可见字符串
             */
            getMarketCode: function(code, callback) {
                thsPassport.getMarketCode(code).then(function(data) {
                    callback(data);
                });
            }

        };

        cefUtil = {
            /**
             * u1.获取当前客户端使用的皮肤
             * @param  {Function} callback 回调函数
             * @return {String}            返回皮肤的字符串 如：核心风格
             */
            getSkinName: function(callback) {
                thsUtil.getSkinName().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获得所有网卡
             * @param  {int}   type         type: 可以是以下标志位组合  0x1 (物理网卡) , 0x2(USB网卡), 0x4(PCMCIA), 0x8(虚拟网卡), 0x10(有线), 0x20(无线) 分
             *                                    我们这里传0xFF（所有网卡）
             * @param  {Function} callback  回调函数
             * @return {String}             1a-7b-2e-0c-f5-62;
             */
            getMacAddress: function(type, callback) {
                thsUtil.getMacAddress(type).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取当前客户端的版本号
             * @param  {Function} callback 回调函数
             * @return {String}            返回版本号
             */
            getHxVer: function(callback) {
                thsUtil.getHxVer().then(function(data) {
                    callback(data);
                });
            },
            //暂时未知
            openAlert: function(key, callback) {
                thsUtil.openAlert(key).then(function(data) {
                    callback(data);
                });
            },
            //暂时未知
            openAppWebDlg: function(url, callback) {
                thsUtil.openAppWebDlg(url).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 打开弹出窗口，然后添加股票到板块
             * @param  {String}   codes    股票代码，只能传一个股票,例如：'300033'
             * @param  {Function} callback 回调函数
             * @return {null}               null
             */
            addCodeToBlock: function(codes, callback) {
                thsUtil.addCodeToBlock(codes).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 打开一个无边框的弹窗
             * @param  {String} url 地址
             * @return {null}       null
             */
            openNoFrameWebDlg: function(url) {
                thsUtil.openNoFrameWebDlg(url);
            },
            /**
             * 打开弹出窗口
             * @param  {String} url  输入一个网址的url
             * @param  {int} type   type值可取：1,2,3,4中的某一个,常用的取4
             *                      1:用资讯框打开
             *                      2:用客户端浏览器打开
             *                      3:用指标平台蓝色框打开
             *                      4:用客户端浏览器打开
             *                      9:用无边框客户端浏览器打开
             * @return {null}      null
             */
            openURL: function(url, type) {
                thsUtil.openURL(url, type);
            },
            /**
             * 获取指标内容
             * @param  {Number}   id       行情公式id 如：11（收盘价）
             * @param  {Function} callback 回调函数
             * @return {String}            返回指标内容 如：
             * //#@version=31
             * //#@Fname=CLOSE
             * //#@comment=含义：当周期的收盘价。
             * //#|用于：个股的分钟K线、日K线周期。沪深指数的分钟K线、日K线周期。
             * //#@control=
             * //#@FuncType=
             * //#@availperiod=83
             * //#@isDrawCurve=0
             * //#@param=
             * //#@Fdesc=收盘
             * //#@defaultperiod=28483
             * //#@extension=ConfigName=同花顺方案
             * //#|catalog=系统公式;行情数据;通用数据;
             * //#|
             * //#|
             */
            getFormulaContentById: function(id, callback) {
                thsUtil.getFormulaContentById(id).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 显示母子网页弹窗
             * @param  {Object}   obj      参数对象 {
             *                              url:网页地址
             *                              id:子页面id
             *                              parentID:父页面id
             *                              type:弹窗风格（选项未知）
             *                             }
             * @param  {Function} callback [description]
             * @return {Number}            返回id值，若id值为0，将随机指定一个id
             */
            showPSWebDlg: function(obj, callback) {
                thsUtil.showPSWebDlg(obj).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 关闭对应的母子网页的弹窗
             * @param  {String} id 要关闭的弹窗的id
             * @return {null}
             */
            closePSWebDlg: function(id) {
                thsUtil.closePSWebDlg(id);
            },
            /**
             * 重置母子网页弹窗大小
             * @param  {Number} id     要设置弹窗大小的弹窗的id
             * @param  {Number} width  宽 如：200
             * @param  {Number} height 高 如：200
             * @return {null}
             */
            resizePSWebDlg: function(id, width, height) {
                thsUtil.resizePSWebDlg(id, width, height);
            },
            /**
             * 获取用户自定义板块的名称和id
             * @param  {Function} callback 回调函数
             * @return {String}            返回自定义板块的名称和id 如：{"list":[{"id":35,"name":"板块1"},{"id":36,"name":"板块2"}]}
             */
            getSelfBlockMessage: function(callback) {
                thsUtil.getSelfBlockMessage().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取板块ID获取板块名称
             * @param  {Number}   blockId  板块id
             * @param  {Function} callback 回调函数
             * @return {String}            返回板块ID获取板块名称 如何：33:000420,33:002636,33:300472
             */
            getBlockStockByID: function(blockId, callback) {
                thsUtil.getBlockStockByID(blockId).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 指定一个图片名，获取截图图片的文件全路径
             * @param  {String}   filePath 图片名字或路径加图片名字（无后缀，默认为jpg）
             * @param  {Function} callback 回调函数
             * @return {String}            返回图片的文件全路径
             */
            getScreenCaptureFileName: function(filePath, callback) {
                thsUtil.getScreenCaptureFileName(filePath).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取一个base64加密过的文件内容
             * @param  {String}   encryptFilePath 文件去路径 如：D:/software/newClientUpdate/同花顺9_cef20170425_Dev开发版/同花顺9_cef20170425_Dev/web大金融1/test.txt
             * @param  {Function} callback        回调函数
             * @return {String}                   返回解密过的文件内容
             */
            getFileBase64: function(encryptFilePath, callback) {
                thsUtil.getFileBase64(encryptFilePath).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 删除某个文件
             * @param  {String}   filePath 文件全路径
             * @param  {Function} callback 回调函数
             * @return {Boolean}           返回是否删除
             */
            deleteFile: function(filePath, callback) {
                thsUtil.deleteFile(filePath).then(function(data) {
                    callback(data);
                });
            },
            /**
             * TODO
             * 形态预测购买完成后，通知客户端刷新权限
             * @param  {Function} callback 回调函数
             * @return {null}
             */
            formPreFinishPay: function(callback) {
                thsUtil.formPreFinishPay().then(function(data) {
                    callback(data);
                });
            },
            /**
             * [成功统计率，最优指标]通过指标平台ID获取公式ID
             * @param  {Number}   platId   指标平台id
             * @param  {Function} callback 回调函数
             * @return {Number}            公式id
             */
            findFuncIdByPlatformId: function(platId, callback) {
                thsUtil.findFuncIdByPlatformId(platId).then(function(data) {
                    callback(data);
                });
            },
            /**
             * [成功统计率，最优指标]获取绘制策略买卖点的信息
             * @param  {String}   xmlStr   买卖点数据的xml
             * @param  {Function} callback 回调函数
             * @return {Boolean}            若客户端解析xml成功后，返回true
             */
            strategyBuy: function(xmlStr, callback) {
                thsUtil.strategyBuy(xmlStr).then(function(data) {
                    callback(data);
                });
            },
            /**
             * [成功统计率，最优指标]清除绘制策略买卖点的信息
             * @param  {Function} callback 回调函数
             * @return {Boolean}            若客户端清除买卖点成功后，返回true
             */
            clearStrategyBuy: function(callback) {
                thsUtil.clearStrategyBuy().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 向前复权，补去有除权缺口的图形，便于分析；JS向客户端发生一个菜单消息ID_FUQUAN
             * @param  {Function} callback 回调函数
             * @return {null} 
             */
            qltfuquan: function(callback) {
                thsUtil.qltfuquan().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 取消复权，JS向客户端发送一个菜单消息ID_FUQUAN_CANCEL
             * @param  {Function} callback 回调函数
             * @return {null}
             */
            qltfuquancancel: function(callback) {
                thsUtil.qltfuquancancel().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获取复权状态
             * @param  {Function} callback 回调函数
             * @return {null}
             */
            getfuquanstate: function(callback) {
                thsUtil.getfuquanstate().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 把应用中心显示方案写到客户端本地
             * @param {String}   strContent 应用中心显示方案
             * @param {Function} callback   回调函数
             * @return {Boolean}            返回是否成功
             */
            WriteAppCenterSynContent: function(strContent, callback) {
                thsUtil.WriteAppCenterSynContent(strContent).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 把应用中心显示方案读取给应用中心网页
             * @param {Function} callback 回调函数
             * @return {String}           应用中心显示方案
             */
            ReadAppCenterSynContent: function(callback) {
                thsUtil.ReadAppCenterSynContent().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 根据用户组类型获取用户组ID
             * @param  {Number}   nUserGroupType 用户组类型
             * @param  {Function} callback       回调函数
             * @return {Number}                  用户组id
             */
            getUserGroupID: function(nUserGroupType, callback) {
                thsUtil.getUserGroupID(nUserGroupType).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 显示网页弹窗，此弹窗是为了解决应用中心弹窗网页不被覆盖而存在的
             * @param  {String}   url      地址
             * @param  {Function} callback 回调函数
             * @return {null} 
             */
            openAppCenterIndexDlg: function(url, callback) {
                thsUtil.openAppCenterIndexDlg(url).then(function(data) {
                    callback(data);
                });
            },

        };

        //external对象
        cefExternal = {
            /**
             * 获得当前客户端的用户目录
             * @param  {Function} callback 回调函数
             * @return {String}            返回当前客户端的目录
             */
            getUserPath: function(callback) {
                ThsExternal.getUserPath().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 获得当前客户端根目录
             * @param  {Function} callback 回调函数
             * @return {String}            返回当前客户端的目录
             */
            getModulePath: function(callback) {
                ThsExternal.getModulePath().then(function(data) {
                    callback(data);
                });
            },
            closeWindow: function() {
                ThsExternal.closeWindow();
            },
            setWindowWidth: function(params, callback) {
                ThsExternal.setWindowWidth(params).then(function(data) {
                    callback(data);
                });
            },
            setWindowRect: function(params, callback) {
                ThsExternal.setWindowRect(params).then(function(data) {
                    callback(data);
                });
            },
            IsLeftBarVisible: function(callback) {
                ThsExternal.IsLeftBarVisible().then(function(data) {
                    callback(data);
                });
            },
            ShowLeftBar: function(show, callback) {
                ThsExternal.ShowLeftBar(show).then(function(data) {
                    callback(data);
                });
            },
            offsetWindowRect: function(params, callback) {
                ThsExternal.offsetWindowRect(params).then(function(data) {
                    callback(data);
                });
            },
            minimizeWindow: function(callback) {
                ThsExternal.minimizeWindow().then(function(data) {
                    callback(data);
                });
            },
            closeWebDlg: function() {
                ThsExternal.closeWebDlg();
            },
            moveWindowByMessage: function(type, callback) {
                ThsExternal.moveWindowByMessage(type).then(function(data) {
                    callback(data);
                });
            }
        };

        //读取文件对象
        cefFileReader = {
            open: function(filePath, callback) {
                thsFileReader.open(filePath).then(function(data) {
                    callback(data);
                });
            },
            read: function(callback) {
                thsFileReader.read().then(function(data) {
                    callback(data);
                });
            },
            readBin: function(callback) {
                thsFileReader.readBin().then(function(data) {
                    callback(data);
                });
            },
            readDes: function(callback) {
                thsFileReader.readDes().then(function(data) {
                    callback(data);
                });
            },
            close: function(callback) {
                thsFileReader.close().then(function(data) {
                    callback(data);
                });
            },
            /**
             * 读取客户端本地文件
             * @param  {String}   file     文件名称
             * @param  {Function} callback 回调函数
             * @return {Object}            返回一个对象
             */
            getFileContent: function(file, callback) {
                ThsExternal.getUserPath().then(function(data) {
                    thsFileReader.open(data + file).then(function(data) {
                        if (data) {
                            thsFileReader.read().then(function(data) {
                                //data =new Function('return '+data)();
                                // data = eval('(' + data + ')');
                                // console.log(data);
                                callback(eval('(' + data + ')'));
                                thsFileReader.close();
                            });
                        } else {
                            callback();
                        }
                    });
                });
            }

        };

        //写入文件对象
        cefFileWriter = {
            open: function(filePath, callback) {
                thsFileWriter.open(filePath).then(function(data) {
                    callback(data);
                });
            },
            write: function(strContent, callback) {
                thsFileWriter.write(strContent).then(function(data) {
                    callback(data);
                });
            },
            /**
             * 向客户端用户目录写文件
             * @param  {String}   file     文件名称,例如：'cai.ini'
             * @param  {String}   jsonStr  字符串,例如：'123456888'
             * @param  {Function} callback 回调函数
             * @return {int}               返回写入的字符个数,例如：22
             */
            writeFileContent: function(file, jsonStr, callback) {
                ThsExternal.getUserPath().then(function(data) {
                    thsFileWriter.open(data + file).then(function(data) {
                        if (data) {
                            thsFileWriter.write(jsonStr).then(function(data) {
                                thsFileWriter.close();
                                callback(data);
                            });
                        } else {
                            callback();
                        }
                    });
                });
            }
        };



        //IE浏览器兼容
    } else {

        thsQuote = external.createObject('Quote');
        thsUtil = external.createObject('Util');
        thsPassport = external.createObject('Passport');
        thsFileReader = external.createObject('FileInputStream');
        thsFileWriter = external.createObject('FileOutputStream');

        cefQuote = {
            getServerTime: function(callback) {
                var time = thsQuote.getServerTime();
                callback(time);
            },
            syncStockList: function(param) {
                thsQuote.syncStockList(param);
            },
            getSHTradeDate: function(lDate, callback) {
                var data = thsQuote.getSHTradeDate(lDate);
                callback(data);
            },
            getHxCurPageID: function(callback) {
                var data = thsQuote.getHxCurPageID();
                callback(data);
            },
            getHxCurPageName: function(callback) {
                var data = thsQuote.getHxCurPageName();
                callback(data);
            },
            request: function(params) {
                thsQuote.request(params);
            },
            getData: function(params, callback) {
                var data = thsQuote.getData(params);
                callback(data);
            },
            getData2: function(params, callback) {
                var data = thsQuote.getData2(params);
                callback(data);
            },
            registerPush: function(params) {
                var thsQuote = external.createObject('Quote');
                thsQuote.registerPush(params);
                return thsQuote;
            },
            getStockCode: function(code, callback) {
                var data = thsQuote.getStockCode(code);
                callback(data);
            },
            getStockType: function(code, callback) {
                var data = thsQuote.getStockType(code);
                callback(data);
            },
            getPeriodNum: function(params, callback) {
                var data = thsQuote.getPeriodNum(params);
                callback(data);
            },
            getIndexAndIndustry: function(code, callback) {
                var data = thsQuote.getIndexAndIndustry(code);
                callback(data);
            },
            switchPageByURL: function(code) {
                thsQuote.switchPageByURL(params);
            },
            switchPage: function(code) {
                thsQuote.switchPage(params);
            },
            switchCode: function(code) {
                thsQuote.switchCode(params);
            }
        };

        cefPassport = {
            selfStocks: function(callback) {
                var data = thsPassport.selfStocks();
                callback(data);
            },
            get: function(key, callback) {
                var data = thsPassport.get(key);
                callback(data);
            },
            getAccountInfo: function(callback) {
                var data = thsPassport.getAccountInfo();
                callback(data);
            },
            getAccountAllInfo: function(callback) {
                var data = thsPassport.getAccountAllInfo();
                callback(data);
            },
            selfIndustries: function(callback) {
                var data = thsPassport.selfIndustries();
                callback(data);
            },
            getPassword: function(callback) {
                var data = thsPassport.getPassword();
                callback(data);
            },
            IsLevel2User: function(callback) {
                var data = thsPassport.IsLevel2User();
                callback(data);
            },
            holdStocks: function(callback) {
                var data = thsPassport.holdStocks();
                callback(data);
            },
            curStock: function(callback) {
                var data = thsPassport.curStock();
                callback(data);
            },
            getPassport: function(type, callback) {
                var data = thsPassport.getPassport(type);
                callback(data);
            },
            getSignature: function(type, callback) {
                var data = thsPassport.getSignature(type);
                callback(data);
            },
            getMarketCode: function(code, callback) {
                var data = thsPassport.getMarketCode(code);
                callback(data);
            }
        };

        cefUtil = {
            getSkinName: function(callback) {
                var data = thsUtil.getSkinName();
                callback(data);
            },
            getMacAddress: function(type, callback) {
                var data = thsUtil.getMacAddress(type);
                callback(data);
            },
            getHxVer: function(callback) {
                var data = thsUtil.getHxVer();
                callback(data);
            },
            openAlert: function(key, callback) {
                var data = thsUtil.openAlert(key);
                callback(data);
            },
            openAppWebDlg: function(url, callback) {
                var data = thsUtil.openAppWebDlg(url);
                callback(data);
            },
            addCodeToBlock: function(codes, callback) {
                var data = thsUtil.addCodeToBlock(codes);
                callback(data);
            },
            openNoFrameWebDlg: function(url) {
                thsUtil.openNoFrameWebDlg(url);
            },
            openURL: function(url, type) {
                thsUtil.openNoFrameWebDlg(url, type);
            },
            getFormulaContentById: function(id, callback) {
                var data = thsUtil.getFormulaContentById(id);
                callback(data);
            },
            showPSWebDlg: function(obj, callback) {
                var data = thsUtil.showPSWebDlg(obj);
                callback(data);
            },
            closePSWebDlg: function(id) {
                thsUtil.closePSWebDlg(id);
            },
            resizePSWebDlg: function(id, width, height) {
                thsUtil.resizePSWebDlg(id, width, height);
            },
            getSelfBlockMessage: function(callback) {
                var data = thsUtil.getSelfBlockMessage();
                callback(data);
            },
            getBlockStockByID: function(blockId, callback) {
                var data = thsUtil.getBlockStockByID(blockId);
                callback(data);
            },
            getScreenCaptureFileName: function(filePath, callback) {
                var data = thsUtil.getScreenCaptureFileName(filePath);
                callback(data);
            },
            getFileBase64: function(encryptFilePath, callback) {
                var data = thsUtil.getFileBase64(encryptFilePath);
                callback(data);
            },
            deleteFile: function(filePath, callback) {
                var data = thsUtil.deleteFile(filePath);
                callback(data);
            },
            formPreFinishPay: function(callback) {
                var data = thsUtil.formPreFinishPay();
                callback(data);
            },
            findFuncIdByPlatformId: function(platId, callback) {
                var data = thsUtil.findFuncIdByPlatformId(platId);
                callback(data);
            },
            strategyBuy: function(xmlStr, callback) {
                var data = thsUtil.strategyBuy(xmlStr);
                callback(data);
            },
            clearStrategyBuy: function(callback) {
                var data = thsUtil.clearStrategyBuy();
                callback(data);
            },
            qltfuquan: function(callback) {
                var data = thsUtil.qltfuquan();
                callback(data);
            },
            qltfuquancancel: function(callback) {
                var data = thsUtil.qltfuquancancel();
                callback(data);
            },
            getfuquanstate: function(callback) {
                var data = thsUtil.getfuquanstate();
                callback(data);
            },
            WriteAppCenterSynContent: function(strContent, callback) {
                var data = thsUtil.WriteAppCenterSynContent(strContent);
                callback(data);
            },
            ReadAppCenterSynContent: function(callback) {
                var data = thsUtil.ReadAppCenterSynContent();
                callback(data);
            },
            getUserGroupID: function(nUserGroupType, callback) {
                var data = thsUtil.getUserGroupID(nUserGroupType);
                callback(data);
            },
            openAppCenterIndexDlg: function(url, callback) {
                var data = thsUtil.openAppCenterIndexDlg(url);
                callback(data);
            }

        };

        cefExternal = {
            getUserPath: function(callback) {
                var data = external.getUserPath();
                callback(data);
            },
            getModulePath: function(callback) {
                var data = external.getModulePath();
                callback(data);
            },
            closeWindow: function() {
                external.closeWindow();
            },
            setWindowWidth: function(params, callback) {
                var data = external.setWindowWidth(params);
                callback(data);
            },
            setWindowRect: function(params, callback) {
                var data = external.setWindowRect(params);
                callback(data);
            },
            IsLeftBarVisible: function(callback) {
                var data = external.IsLeftBarVisible();
                callback(data);
            },
            ShowLeftBar: function(show, callback) {
                var data = external.ShowLeftBar(show);
                callback(data);
            },
            offsetWindowRect: function(params, callback) {
                var data = external.offsetWindowRect(params);
                callback(data);
            },
            minimizeWindow: function(callback) {
                var data = external.minimizeWindow();
                callback(data);
            },
            closeWebDlg: function() {
                external.closeWebDlg();
            },
            moveWindowByMessage: function(type, callback) {
                var data = external.moveWindowByMessage(type);
                callback(data);
            }
        };

        cefFileReader = {
            open: function(filePath, callback) {
                var data = thsFileReader.open(filePath);
                callback(data);
            },
            read: function(callback) {
                var data = thsFileReader.read();
                callback(data);
            },
            readBin: function(callback) {
                var data = thsFileReader.readBin();
                callback(data);
            },
            readDes: function(callback) {
                var data = thsFileReader.readDes();
                callback(data);
            },
            close: function(callback) {
                var data = thsFileReader.close();
                callback(data);
            },
            getFileContent: function(file, callback) {
                var userPath = external.getUserPath();
                if (thsFileReader.open(userPath + file)) {
                    var data = thsFileReader.read();
                    callback(data);
                    thsFileReader.close();
                } else {
                    callback();
                }
            }
        };

        cefFileWriter = {
            open: function(filePath, callback) {
                var data = thsFileWriter.open(filePath);
                callback(data);
            },
            write: function(filePath, callback) {
                var data = thsFileWriter.write(filePath);
                callback(data);
            },
            writeFileContent: function(file, jsonStr, callback) {
                var userPath = external.getUserPath();
                if (thsFileWriter.open(userPath + file)) {
                    var data = thsFileWriter.write(jsonStr);
                    callback(data);
                    thsFileWriter.close();
                } else {
                    callback();
                }
            }
        };


    }

    //总对外接口
    window.cefClientApi = {
        thsQuote: cefQuote,
        thsPassport: cefPassport,
        thsUtil: cefUtil,
        thsExternal: cefExternal,
        thsFileReader: cefFileReader,
        thsFileWriter: cefFileWriter,
        /**
         * 推送服务自定义函数
         * @param  {Function} fn         自定义推送数据后执行的函数
         * @param  {int}      threshhold 推送间隔时间,默认250ms
         * @param  {Object}   scope      作用域，传个this进来
         * @return {Function}            返回一个用户自定义函数
         */
        throttle: function(fn, threshhold, scope) {
            threshhold = threshhold || 250;
            var lastPub,
                timerPub;
            return function() {
                var context = scope || this;
                var now = +new Date(),
                    args = arguments;
                if (lastPub && now - lastPub < threshhold) {
                    clearTimeout(timerPub);
                    var delay = threshhold - (now - lastPub);
                    timerPub = setTimeout(function() {
                        lastPub = +new Date();
                        fn.apply(context, args);
                    }, delay);
                } else {
                    lastPub = now;
                    fn.apply(context, args);
                }
            };
        }
    };

    /**
     * [isIE 判断是否是IE浏览器]
     * @return {Boolean} [true:是,false:否]
     */
    function isIE() {
        if (!!window.ActiveXObject || 'ActiveXObject' in window) {
            return true;
        } else {
            return false;
        }
    }

})();
